JavaScript高级程序设计学习笔记之继承模式

原型链

JavaScript的继承主要依靠原型链来实现的。我们知道，构造函数，原型，和实例之间的关系：每个构造函数都有一个原型对象，原型对象都包含一个指向构造函数的指针，而实例都包含一个原型对象的指针。

实现原型链的方式如下

function  SuperType(){
    this.property=true;
}
SuperType.prototype.getSuperValue=function(){
    return this.property;
};

function  SubType(){
    this.subpropertype=false;
}
//让原型对象称为另一个构造函数的实例
SubType.prototype=new SuperType();

SubType.prototype.getSubValue=function(){
    return this.subpropertype;
};
var  instance=new SubType();
alert(instance.getSuperValue());//true
//这个实例继承了SuperType.prototype的constructor属性？
alert(instance.constructor==SuperType);//true

上述代码继承是通过SubType.prototype=new SuperType();来实现，创建SuperType的实例，并将该实例赋给SubType.prototype。

继承实现的本质是重写原型对象，代之以一个新类型的实例。

下图为构造函数，实例以及原型之间的关系图：

图片描述

原型链顶端:所有引用类型都默认继承Object，所以，所有函数的默认原型都是Object的实例，默认原型都会包含一个内部指针[[prototype]]，指向Object.prototype。

原型链缺点

1. 实例属性变为原型属性

function  SuperType(){
    this.color=["red","green","blue"];
}
function  SubType(){

}
SubType.prototype = new SuperType();

var instance1 = new SubType();
instance1.color.push("black");
alert(instance1.color);//"red,green,blue,black"

var instance2 = new SubType();
alert(instance2.color);//"red,green,blue,black"

这个问题似曾相识，正是原型模式创建对象时由于共享引用类型属性，导致牵一发动全身的问题。

1. 在创建子类型时，不能向超类型的构造函数传递参数。

所以，单独使用原型链情况较少。

借用构造函数

针对原型链的第一个问题，我们可采用借用构造函数的技术来解决。基本思想就是在子类型构造函数的内部调用超类型构造函数。看例子：

function  SuperType(){
    this.color=["red","green","blue"];
}
function  SubType(){
    //继承自SuperType
    SuperType.call(this);
}
var instance1 = new SubType();
instance1.color.push("black");
alert(instance1.color);//"red,green,blue,black"

var instance2 = new SubType();
alert(instance2.color);//"red,green,blue"

在新创建的SubType子类型的实例中调用SuperType超类型构造函数，就可以在新的实例对象上执行SuperType()函数中定义的所有对象初始化代码。问题不就解决了吗！
但是，这种模式的缺点是在超类型中定义的方法，对子类型是不可见的，无法实现共享方法。
所以，这种方法也不常用。

组合继承

组合上述两种方法就是组合继承。用原型链实现对原型属性和方法的继承，用借用构造函数技术来实现实例属性的继承。无疑，集两者之大成，这才是最常用的继承模式。看：

function  SuperType(){
    this.name=name;
    this.color=["red","green","blue"];
}
SuperType.prototype.sayName = function(){
    alert(this.name);
}
function  SubType(name,age){
    //继承了SuperType
    SuperType.call(this,name);
    //自己又添加了一个
    this.age = age;
}
//构建原型链
SubType.prototype = new SuperType();
//重写SubType.prototype的constructor属性，指向自己的构造函数SubType
SubType.prototype.constructor=SubType;
//原型方法，被实例们共享
SubType.prototype.sayAge = function(){
    alert(this.age);
}

var instance1 = new SubType("Nichola",29);
instance1.color.push("black");
alert(instance1.color);//"red,green,blue,black"
instance1.sayName();//"Nichola"
instance1.sayAge();//29

var instance2 = new SubType("Grey",24);
alert(instance2.color);//"red,green,blue"
instance2.sayAge();//24
instance2.sayName();//"Grey"

这个方案已经看似perfect了。但是，后面再说。

原型式继承

借助原型可以基于已有的对象创建新的对象，不必因此创建自定义类型。

function object(o){     //返回一个对象以传入对象为原型
    function F(){}
    F.prototype = o;
    return new F();
}

var person ={
    name:"Nichola",
    friends:["Shelly","Court","Van"]
};
var person1 = object(person);
person1.name = "Grey";
person1.friends.push("Rob");

var person2 = object(person);
person2.name = "Linda";
person2.friends.push("Barble");

alert(person.friends);//"Shelly,Court,Van,Grey,Barble"

使用场合：需求简单，只需要让新对象与已有对象保持相似。优点，不必创建构造函数，缺点，包含引用类型值的属性始终共享相应的值。
Object.create()正是为实现这种模式诞生。

寄生式继承

与原型式继承相似，也是基于某个对象或某些信息创建对象，然后增强对象，最后返回对象。实现方法：创建一个仅用于封装继承过程的函数，该函数在内部以某种方式来增强对象，最后返回这个对象。看！

function createAnother(original){
    var clone = object(original);//通过调用函数创建对象
    clone.sayHi= function (){    //增强对象
        alert("Hi");
    };
    return clone;//返回对象
}
//可以返回新对象的函数
function object(o){
    function F(){}
    F.prototype = o;
    return new F();
}

var person ={
    name:"Nichola",
    friends:["Shelly","Court","Van"]
};

var anotherPerson = createAnother(person);
anotherPerson.sayHi();//"Hi"

这种继承模式适用的场合：任何返回新对象的函数都可以。缺点是不能做到函数复用。

寄生组合式继承

上面说到组合继承也有缺点，就是无论在何种情况下，都会调用两次超类型构造函数，一次是在创建子类型原型时，还有一次是在子类型构造函数内部。
这种模式集中了寄生式和组合式继承的优点。

function  SuperType(){
    this.name=name;
    this.color=["red","green","blue"];
}
function  SubType(){
    //第二次调用SuperType()
    SuperType.call(this,name);
 
    this.age = age;
}
//第一次调用SuperType()
SubType.prototype = new SuperType();

SubType.prototype.constructor=SubType;

SubType.prototype.sayAge = function(){
    alert(this.age);
}

var instance1 = new SubType("Nichola",29);

第一次调用SuperType():给SubType.prototype写入两个属性name，color
第二次调用SuperType()：给instance1写入两个属性name，color
实例对象instance1上的两个属性就屏蔽了其原型对象SubType.prototype的两个同名属性。所以，组合模式的缺点就是在SubType.prototype上创建不必要的重复的属性。
寄生组合式继承基本模式：

function  inheritPrototype(SubType,SuperType){
    var prototype = object(superType.prototype);//创建对象
    prototype.constructor = SubType;//增强对象
    SubType.prototype = prototype;//制定对象
}

首先，创建超类型的一个副本；
其次，为副本添加constructor属性，使其指向子类型构造函数；
最后，将副本赋值给子类型原型。

function  SuperType(){
    this.name=name;
    this.color=["red","green","blue"];
}
function  SubType(){
    SuperType.call(this.name);
    this.age = age;
}
function  inheritPrototype(SubType,SuperType){
    var prototype = object(superType.prototype);//创建对象
    prototype.constructor = SubType;//增强对象
    SubType.prototype = prototype;//制定对象
}
SubType.prototype.sayAge = function(){
    alert(this.age);
}

var instance1 = new SubType("Nichola",29);

借用构造函数来继承实例属性，使用寄生式继承来继承超类型的原型，然后再将结果赋给子类型原型。这样既可以继承超类型的实例属性，也可继承超类型原型中的原型属性。这是最优解。